/**
 * 简化版权限钩子
 * 
 * 提供简洁的权限检查API
 * 不涉及复杂的缓存机制，适合毕业设计使用
 */
import { useCallback, useState, useEffect } from 'react';
import { useSelector, useDispatch } from 'react-redux';
import { RootState } from '../store';
import auth from '../utils/auth';
import { User } from '../types';
import { News } from '../types/news';
import { getStorageItem } from '../utils/storage';
import { STORAGE_KEYS, ROLE_TYPES } from '../constants/common';
import { setRights } from '../store/features/userSlice';

/**
 * 简化版权限钩子
 * 提供权限检查、角色判断和部门隔离功能
 */
export const useSimpleAuth = () => {
  // 从Redux获取权限数据，确保路径与store结构匹配
  const rights = useSelector((state: RootState) => state.user?.rights || []);
  const user = useSelector((state: RootState) => state.user?.userInfo);
  const dispatch = useDispatch();
  const [localRights, setLocalRights] = useState<string[]>([]);
  
  // 在组件挂载时从localStorage获取权限数据
  useEffect(() => {
    // 如果Redux中没有权限数据，尝试从localStorage获取
    if (!rights || rights.length === 0) {
      const storedRights = getStorageItem<string[]>(STORAGE_KEYS.USER_RIGHTS, []);
      if (storedRights && storedRights.length > 0) {
        console.log('[useSimpleAuth] 从localStorage获取到权限列表:', storedRights);
        setLocalRights(storedRights);
        // 同步到Redux
        dispatch(setRights(storedRights));
      }
    } else {
      setLocalRights(rights);
    }
  }, [rights, dispatch]);

  /**
   * 检查是否有特定权限
   * @param permission 权限代码
   * @returns 是否有权限
   */
  const hasPermission = useCallback(
    (permission: string): boolean => {
      // 增强的超级管理员检查逻辑
      // 从Redux和localStorage双重获取用户信息
      const userInfo = user || JSON.parse(localStorage.getItem('userInfo') || '{}');
      
      // 全面检查超级管理员身份 - 支持多种格式
      const isSuperAdminUser = 
        // 检查role对象中的角色类型
        userInfo?.role?.roleType === ROLE_TYPES.SUPER_ADMIN || 
        // 检查角色名称
        userInfo?.role?.roleName === '超级管理员' ||
        // 直接检查roleId(数字格式)
        userInfo?.roleId === 1 || 
        // 直接检查roleId(字符串格式)
        userInfo?.roleId === '1' ||
        // 检查全局auth工具中的判断
        auth.isSuperAdmin();
      
      // 超级管理员总是拥有所有权限
      if (isSuperAdminUser) {
        console.log('[权限检查] 超级管理员权限自动通过:', permission);
        return true;
      }
      
      // 非超级管理员的权限检查逻辑
      // 使用localRights或Redux中的rights
      const effectiveRights = localRights.length > 0 ? localRights : rights;
      
      // 输出权限检查详情(调试用)
      console.log('[权限检查]', {
        permission,
        hasPermission: effectiveRights.includes(permission),
        userRights: effectiveRights,
        userInfo: {
          username: userInfo?.username,
          roleId: userInfo?.roleId,
          roleName: userInfo?.role?.roleName
        }
      });
      
      // 检查是否有指定权限
      return effectiveRights.includes(permission);
    },
    [rights, localRights, user]
  );

  /**
   * 是否为超级管理员
   * @returns 是否为超级管理员
   */
  const isSuperAdmin = useCallback((): boolean => {
    return auth.isSuperAdmin();
  }, []);

  /**
   * 是否为区域管理员
   * @returns 是否为区域管理员
   */
  const isRegionAdmin = useCallback((): boolean => {
    return auth.isRegionAdmin();
  }, []);

  /**
   * 是否为普通编辑
   * @returns 是否为编辑
   */
  const isEditor = useCallback((): boolean => {
    return auth.isEditor();
  }, []);

  /**
   * 获取当前用户的区域/部门
   * @returns 用户所属区域
   */
  const getUserRegion = useCallback((): string => {
    return auth.getUserRegion();
  }, []);

  /**
   * 检查是否可以访问指定区域
   * @param region 区域代码
   * @returns 是否可以访问
   */
  const canAccessRegion = useCallback(
    (region: string): boolean => {
      return auth.canAccessRegion(region);
    },
    []
  );

  /**
   * 检查是否可以管理指定作者的内容
   * @param author 作者用户名
   * @returns 是否可以管理
   */
  const canManageAuthor = useCallback(
    (author: string): boolean => {
      return auth.canManageAuthor(author);
    },
    []
  );

  /**
   * 检查是否可以执行特定操作
   * 基于CRUD权限模型
   * @param operation 操作类型，如'create'、'read'、'update'、'delete'
   * @param resource 可选的资源类型
   * @returns 是否可以执行操作
   */
  const canPerformOperation = useCallback(
    (operation: string, resource?: string): boolean => {
      // 超级管理员可以执行任何操作
      if (isSuperAdmin()) return true;

      // 构建权限代码
      let permission: string;
      if (resource) {
        permission = `/${resource}/${operation}`;
      } else {
        permission = `/${operation}`;
      }

      return hasPermission(permission);
    },
    [isSuperAdmin, hasPermission]
  );

  /**
   * 按部门过滤用户列表
   * 这里明确定义User类型和返回类型
   */
  const filterUsersByDepartment = useCallback(
    (users: User[]): User[] => {
      try {
        // 确保users是数组
        const userArray = Array.isArray(users) ? users : [];
        // 使用auth实例的方法并绑定正确的上下文
        return auth.filterUsersByDepartment(userArray);
      } catch (error) {
        console.error('过滤用户列表失败:', error);
        return [];
      }
    },
    []
  );

  /**
   * 检查当前是否已认证
   */
  const isAuthenticated = useCallback((): boolean => {
    return auth.isAuthenticated();
  }, []);

  /**
   * 登出处理
   */
  const logout = useCallback((): void => {
    auth.logout();
  }, []);

  /**
   * 按部门过滤新闻列表
   * 使用回调函数包装auth方法以保持this上下文，并增加错误处理
   */
  const filterNewsByDepartment = useCallback(
    (news: News[]): News[] => {
      try {
        // 确保news是数组
        const newsArray = Array.isArray(news) ? news : [];
        // 直接调用auth实例的方法，保持正确的上下文
        return auth.filterNewsByDepartment(newsArray);
      } catch (error) {
        console.error('过滤新闻列表失败:', error);
        return [];
      }
    },
    []
  );

  // 重置用户权限，用于解决权限缓存问题
  const resetUserRights = useCallback((): void => {
    const userInfo = auth.getUserInfo();
    if (userInfo && userInfo.role?.rights) {
      auth.setUserRights(userInfo.role.rights);
      dispatch(setRights(userInfo.role.rights));
      setLocalRights(userInfo.role.rights);
      console.log('[权限重置] 已重置用户权限', userInfo.role.rights);
    } else {
      console.warn('[权限重置] 无法获取用户权限信息');
    }
  }, [dispatch]);

  return {
    hasPermission,
    isSuperAdmin,
    isRegionAdmin,
    isEditor,
    getUserRegion,
    canAccessRegion,
    canManageAuthor,
    canPerformOperation,
    isAuthenticated,
    logout,
    resetUserRights,
    // 使用回调包装的方法
    filterUsersByDepartment,
    filterNewsByDepartment
  };
};

export default useSimpleAuth; 